home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 August: Tool Chest / Dev.CD Aug 00 TC Disk 2.toast / pc / sample code / interapplication comm / 7edit / source / svaetextutils.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-06-23  |  19.2 KB  |  814 lines
  1. /*
  2.     File:        SVAETextUtils.c
  3.  
  4.     Contains:    
  5.  
  6.     Written by: Original version by Jon Lansdell and Nigel Humphreys.
  7.                 3.1 updates by Greg Sutton.
  8.  
  9.     Copyright:    Copyright © 1995-1999 by Apple Computer, Inc., All Rights Reserved.
  10.  
  11.                 You may incorporate this Apple sample source code into your program(s) without
  12.                 restriction. This Apple sample source code has been provided "AS IS" and the
  13.                 responsibility for its operation is yours. You are not permitted to redistribute
  14.                 this Apple sample source code as "Apple sample source code" after having made
  15.                 changes. If you're going to re-distribute the source, we require that you make
  16.                 it clear in the source that the code was descended from Apple sample source
  17.                 code, but that you've made changes.
  18.  
  19.     Change History (most recent first):
  20.                             7/20/1999    Karl Groethe    Updated for Metrowerks Codewarror Pro 2.1
  21.                 
  22.  
  23. */
  24. #include "SVAETextUtils.h"
  25.  
  26. #include "SVEditAEUtils.h"
  27. #include "SVEditWindow.h"        // for DPtrFromWindowPtr()
  28. #include "SVAERecording.h"
  29.  
  30.  
  31. #include <AEPackObject.h>
  32.  
  33.  
  34.  
  35. // ----------------------------------------------------------------------------------
  36. //    Name:    PutStyledTextFromDescIntoTEHandle
  37. //    Purpose: Takes the text in an AEDesc containing typeIntlText and puts it in
  38. //             a styled text edit record at the current insertion point.
  39. //                     Looks for typeIntlText, typeStyledText, typeChar in that order.
  40. // ----------------------------------------------------------------------------------
  41.  
  42. OSErr    PutStyledTextFromDescIntoTEHandle(const AEDesc *sourceTextDesc, TEHandle theHTE)
  43. {
  44.     AEDesc styledTextDesc;
  45.     AEDesc textStyleDesc;
  46.     AEDesc rawTextDesc;
  47.     OSErr  myErr;
  48.     OSErr  ignoreErr;
  49.     
  50.     styledTextDesc.dataHandle = nil;
  51.     textStyleDesc.dataHandle  = nil;
  52.     rawTextDesc.dataHandle    = nil;
  53.     
  54.     //    Coerce to an AERecord and then extract the parts of the
  55.     //    styled text - works for typeIntlText, typeStyledText
  56.  
  57.     myErr = AECoerceDesc(sourceTextDesc, typeAERecord, &styledTextDesc);
  58.     
  59.     if (noErr == myErr)
  60.     {        
  61.         myErr = AEGetKeyDesc(&styledTextDesc,
  62.                                                  keyAEText,
  63.                                                  typeChar,
  64.                                                  &rawTextDesc);
  65.                                                  
  66.         myErr = AEGetKeyDesc(&styledTextDesc,
  67.                                                  keyAEStyles,
  68.                                                  typeScrapStyles,
  69.                                                  &textStyleDesc);
  70.     }
  71.     else
  72.     {
  73.         myErr = AECoerceDesc(sourceTextDesc, typeChar, &rawTextDesc);
  74.         
  75.         textStyleDesc.dataHandle = NULL; // so that TEStylInsert acts like TEInsert                
  76.     }
  77.             
  78.     HLock((Handle)rawTextDesc.dataHandle);
  79.     
  80.     TEDelete(theHTE);                    // Insert over current selection
  81.     TEStyleInsert((const void *) (*rawTextDesc.dataHandle),
  82.                                          GetHandleSize(rawTextDesc.dataHandle),
  83.                                              (StScrpHandle) textStyleDesc.dataHandle,
  84.                                                  theHTE);
  85.                              
  86.     HUnlock((Handle)rawTextDesc.dataHandle);
  87.     
  88.     if (textStyleDesc.dataHandle)
  89.         ignoreErr = AEDisposeDesc(&textStyleDesc);
  90.     
  91.     if (rawTextDesc.dataHandle)
  92.         ignoreErr = AEDisposeDesc(&rawTextDesc);
  93.     
  94.     if (styledTextDesc.dataHandle)
  95.         ignoreErr = AEDisposeDesc(&styledTextDesc);
  96.         
  97.     return(myErr);
  98. }
  99.  
  100.  
  101. TEHandle    TEHandleFromWindow(WindowPtr theWindow)
  102. {
  103.     DPtr        docPtr;
  104.     TEHandle    result = NULL;
  105.     
  106.     if (! theWindow)
  107.         return(NULL);
  108.     
  109.     docPtr = DPtrFromWindowPtr(theWindow);
  110.     
  111.     if (docPtr)
  112.         result = docPtr->theText;
  113.         
  114.     return(result);
  115. }
  116.  
  117. TEHandle    TEHandleFromTextToken(TextToken* aToken)
  118. {
  119.     if (! aToken)
  120.         return(NULL);
  121.         
  122.     return(TEHandleFromWindow(aToken->tokenWindow));
  123. }
  124.  
  125.  
  126. OSErr    GetInsertDescFromInsertHere(AEDesc* insertHereDesc, AEDesc* insertDesc, DescType* insertType)
  127. {
  128.     AEDesc        insertRec = {typeNull, NULL},
  129.                 objectSpec = {typeNull, NULL};
  130.     DescType    returnedType;
  131.     Size        actualSize;
  132.     OSErr        err;
  133.  
  134.      switch (insertHereDesc->descriptorType)
  135.      {
  136.          case typeInsertionLoc:
  137.              err = AECoerceDesc(insertHereDesc, typeAERecord, &insertRec);
  138.              if (noErr != err) goto done;
  139.              
  140.              err = AEGetKeyPtr(&insertRec, keyAEPosition, typeEnumeration, &returnedType,
  141.                                          (Ptr)insertType, sizeof(insertType), &actualSize);
  142.              if (noErr != err) goto done;
  143.  
  144.             err = AEGetKeyDesc(&insertRec, keyAEObject, typeWildCard, &objectSpec);
  145.             if (objectSpec.descriptorType != typeNull)
  146.             {
  147.                 err = AEResolve(&objectSpec, kAEIDoMinimum, insertDesc);
  148.                 if (err != noErr) goto done;
  149.             }
  150.              break;
  151.      
  152.          case typeObjectSpecifier:
  153.              err = AEResolve(insertHereDesc, kAEIDoMinimum, insertDesc);
  154.              if (noErr != err) goto done;
  155.              *insertType = insertDesc->descriptorType;
  156.              break;
  157.              
  158.          case typeNull:                    // No insertion location given
  159.              *insertType = typeNull;
  160.              break;
  161.              
  162.          default:                        // Just copy the descriptor
  163.              err = AEDuplicateDesc(insertHereDesc, insertDesc);
  164.              if (noErr != err) goto done;
  165.              *insertType = insertDesc->descriptorType;
  166.      }
  167.      
  168.  done:
  169.      if (insertRec.dataHandle)
  170.          AEDisposeDesc(&insertRec);
  171.      if (objectSpec.dataHandle)
  172.          AEDisposeDesc(&objectSpec);
  173.      
  174.      return(err);
  175. }
  176.  
  177. // This routine returns an enumerated type describing the relative position
  178. // of one TextToken to another.
  179.  
  180. TokenWithinType    TokenWithinToken(TextToken* container, TextToken* token, short* numPartial)
  181. {
  182.     TokenWithinType        result;
  183.  
  184.     if (token->tokenOffset + token->tokenLength < container->tokenOffset)
  185.         result = kTokenBefore;
  186.     else if (container->tokenOffset + container->tokenLength < token->tokenOffset)
  187.         result = kTokenAfter;
  188.     else if (token->tokenOffset >= container->tokenOffset
  189.                 && token->tokenOffset + token->tokenLength <= container->tokenOffset + container->tokenLength)
  190.         result = kTokenWithin;
  191.     else if (token->tokenOffset < container->tokenOffset)
  192.     {
  193.         result = kTokenPartialBefore;
  194.         if (numPartial)
  195.             *numPartial = token->tokenOffset + token->tokenLength - container->tokenOffset;
  196.     }
  197.     else
  198.     {
  199.         result = kTokenPartialAfter;
  200.         if (numPartial)
  201.             *numPartial = container->tokenOffset + container->tokenLength - token->tokenOffset;
  202.     }
  203.     
  204.     return(result);
  205. }
  206.  
  207.  
  208. OSErr    TextTokenFromWindowToken(WindowToken* theWindowToken, TextToken* theTextToken)
  209. {
  210.     DPtr        docPtr;
  211.  
  212.     docPtr = DPtrFromWindowPtr(theWindowToken->tokenWindow);
  213.  
  214.     if (! docPtr)
  215.         return(errAENoSuchObject);
  216.             // Create our text token
  217.     theTextToken->tokenWindow = theWindowToken->tokenWindow;    
  218.     theTextToken->tokenOffset = 1;                                // Start at 1
  219.     theTextToken->tokenLength = (**docPtr->theText).teLength;    // through whole length
  220.     
  221.     return(noErr);
  222. }
  223.  
  224.  
  225. OSErr    TextTokenFromWindowDesc(AEDesc* windowDesc, TextToken* theToken)
  226. {
  227.     AEDesc            aDesc = {typeNull, NULL};
  228.     WindowToken        aWindowToken;
  229.     Size            actualSize;
  230.     OSErr            err;
  231.     
  232.     err = AECoerceDesc(windowDesc, typeMyWndw, &aDesc);
  233.     if (noErr != err) goto done;
  234.         
  235.     GetRawDataFromDescriptor(&aDesc, (Ptr)&aWindowToken,
  236.                                     sizeof(aWindowToken), &actualSize);
  237.  
  238.     err = TextTokenFromWindowToken(&aWindowToken, theToken);
  239.     
  240. done:    
  241.     if (aDesc.dataHandle)
  242.         AEDisposeDesc(&aDesc);
  243.  
  244.     return(err);
  245. }
  246.  
  247.  
  248. OSErr    TextDescFromWindowToken(WindowToken* theWindowToken, AEDesc* textDesc)
  249. {
  250.     TextToken    aToken;
  251.     OSErr        err;
  252.     
  253.     err = TextTokenFromWindowToken(theWindowToken, &aToken);
  254.     if (noErr != err) goto done;
  255.     
  256.     err = AECreateDesc(typeMyText, (Ptr)&aToken, sizeof(aToken), textDesc);
  257.  
  258. done:
  259.     return(err);
  260. }
  261.  
  262.  
  263. OSErr    TextDescFromWindowDesc(AEDesc* windowDesc, AEDesc* textDesc)
  264. {
  265.     TextToken    aToken;
  266.     OSErr        err;
  267.     
  268.     err = TextTokenFromWindowDesc(windowDesc, &aToken);
  269.     if (noErr != err) goto done;
  270.     
  271.     err = AECreateDesc(typeMyText, (Ptr)&aToken, sizeof(aToken), textDesc);
  272.  
  273. done:
  274.     return(err);
  275. }
  276.  
  277.  
  278. void MoveToNonSpace(short *start, short limit, charsHandle myChars)
  279.     // Treats space, comma, full stop, ; and : as space chars
  280. { 
  281.     short x;
  282.  
  283.     while (*start <= limit) {
  284.       x = (**myChars)[*start];
  285.         if (IsWhiteSpace(x))
  286.             (*start) +=1;
  287.         else
  288.             return;
  289.     }
  290. }
  291.     
  292. void    MoveToSpace(short *start, short limit, charsHandle myChars)
  293.     // Treats space,comma, full stop, ; and : as space chars
  294. { 
  295.     short x;
  296.     
  297.     while (*start <= limit)
  298.     {
  299.         x = (**myChars)[*start];
  300.         if (! IsWhiteSpace(x))
  301.             (*start)++;
  302.         else
  303.             return;
  304.     }
  305. }
  306.  
  307. void    MoveToEndOfParagraph(short *start, short limit, charsHandle myChars)
  308.     //    Treats CR as end of paragraph
  309. { 
  310.     short x;
  311.     
  312.     while (*start <= limit)
  313.     {
  314.         x = (**myChars)[*start];
  315.         if (! IsParagraphDelimiter(x))        // had x != CR
  316.             (*start)++;
  317.         else
  318.             return;
  319.     }
  320. }
  321.  
  322.  
  323. // This routine counts the given elementType between startAt and 
  324.  
  325. OSErr    CountTextElements(TEHandle inTextHandle, short startAt,
  326.                                 short forHowManyChars, DescType elementType, short* result)
  327. {
  328.     charsHandle    theChars;
  329.     short       limit,
  330.                 start;
  331.     OSErr        err = noErr;
  332.  
  333.     switch (elementType)
  334.     {
  335.         case cInsertionPoint:    // Always one more insertion location than characters
  336.             *result = forHowManyChars + 1;
  337.             break;
  338.             
  339.         case cChar:            // Easy
  340.             *result = forHowManyChars;
  341.             break;
  342.             
  343.         case cText:    
  344.             *result = 1;
  345.             break;
  346.         
  347.         case cWord:            // Cycle through - counting
  348.         case cParagraph:
  349.             theChars = (charsHandle)(**inTextHandle).hText;
  350.             start = startAt - 1;                    // Convert to zero based
  351.             limit = start + forHowManyChars - 1;    // when passed one based
  352.             *result    = 0;
  353.             MoveToNonSpace(&start, limit, theChars);
  354.             while (start <= limit)
  355.             {
  356.                 (*result)++;
  357.                 switch (elementType)
  358.                 {
  359.                     case cWord:
  360.                         MoveToSpace(&start, limit, theChars);
  361.                         break;
  362.                         
  363.                     case cParagraph:
  364.                         MoveToEndOfParagraph(&start, limit, theChars);
  365.                         break;
  366.                 }
  367.                 MoveToNonSpace(&start, limit, theChars);
  368.             }
  369.             break;
  370.     
  371.         default:
  372.             *result = -1;
  373.             err = errAEBadKeyForm;
  374.     }
  375.     
  376.     return(err);
  377. } // CountTextElements
  378.  
  379. OSErr    GetDescOfNthTextElement(short index, DescType elementType,
  380.                                         TextToken* containerToken, AEDesc* result)
  381. {
  382.     DPtr        docPtr;
  383.     TextToken    theToken;
  384.     short        start,
  385.                 maxChars,
  386.                 elementCount,
  387.                 limit,
  388.                 elementStart;
  389.     charsHandle    theChars;
  390.     OSErr        err;
  391.     
  392.     if (! containerToken)
  393.         return(errAEEmptyListContainer);
  394.  
  395.     docPtr = DPtrFromWindowPtr(containerToken->tokenWindow);
  396.     start = containerToken->tokenOffset - 1;    // Zero based
  397.     maxChars = containerToken->tokenLength;
  398.  
  399.     err = CountTextElements(docPtr->theText, containerToken->tokenOffset,
  400.                                         maxChars, elementType, &elementCount);
  401.     if (noErr != err) return(err);
  402.     
  403.     if (index < 0)                        // Change a negative index to positive
  404.         index = elementCount + index + 1;
  405.         
  406.     if (index > elementCount)            // Got given an index out of range
  407.         return(errAEIllegalIndex);
  408.         
  409.             // Set the window that the token relates to
  410.     theToken.tokenWindow = containerToken->tokenWindow;
  411.  
  412.     switch (elementType)
  413.     {
  414.         case cInsertionPoint:
  415.             theToken.tokenOffset = start + index - 1;
  416.             theToken.tokenLength = 0;
  417.             break;
  418.             
  419.         case cChar:        // Easy - just the start point + the index
  420.             theToken.tokenOffset = start + index;
  421.             theToken.tokenLength = 1;
  422.             break;
  423.             
  424.         case cText:    
  425.             theToken.tokenOffset = start + index;
  426.             theToken.tokenLength = maxChars;
  427.             break;
  428.             
  429.         case cWord:
  430.         case cParagraph:
  431.             theChars = (charsHandle)(**(docPtr->theText)).hText;
  432.             limit = start + maxChars - 1;
  433.             MoveToNonSpace(&start, limit, theChars);
  434.             while ((start <= limit) && (index > 0))
  435.             {
  436.                 index--;
  437.                 elementStart = start;
  438.                 switch (elementType)
  439.                 {
  440.                     case cWord:
  441.                         MoveToSpace(&start, limit, theChars);
  442.                         break;
  443.                         
  444.                     case cParagraph:
  445.                         MoveToEndOfParagraph(&start, limit, theChars);
  446.                         break;
  447.                 }
  448.                 theToken.tokenLength = start - elementStart;
  449.                 MoveToNonSpace(&start, limit, theChars);
  450.             }
  451.             theToken.tokenOffset = elementStart + 1;    // Convert to one based
  452.             break;
  453.     }
  454.  
  455.     err = AECreateDesc(typeMyText, (Ptr)&theToken, sizeof(theToken), result);
  456.  
  457.     return(err);
  458. }
  459.  
  460.  
  461. char    GetTEHChar(TEHandle aTEH, short offset)
  462. {
  463.     char    result;
  464.     
  465.     offset--;        // This is now 0 based
  466.  
  467.     if (offset < 0 || offset >= (*aTEH)->teLength)
  468.         return('\0');
  469.         
  470.     result = *(char *)((*(**aTEH).hText) + offset);
  471.     
  472.     return(result);
  473. }
  474.  
  475. Boolean        IsAtStart(TextToken* theToken)
  476. {
  477.     Boolean    result;
  478.                     // Is at start if offset is at 1
  479.     result = (theToken->tokenOffset == 1);
  480.     
  481.     return(result);
  482. }
  483.  
  484. Boolean        IsAtEnd(TextToken* theToken)
  485. {
  486.     TEHandle    aTEH;
  487.     Boolean        result;
  488.     
  489.     aTEH = TEHandleFromTextToken(theToken);
  490.                     // Does it go to the end?
  491.     result = (theToken->tokenOffset + theToken->tokenLength >= (**aTEH).teLength);
  492.     
  493.     return(result);
  494. }
  495.  
  496. Boolean        IsWhiteSpace(short aChar)
  497. {
  498.     Boolean    result;
  499.  
  500.     result = (aChar == ' ' || aChar == ',' || aChar == '.'
  501.                 || aChar == ':' || aChar == LF || aChar == CR);
  502.              
  503.     return(result);
  504. }
  505.  
  506. Boolean        IsParagraphDelimiter(short aChar)
  507. {
  508.     Boolean    result;
  509.  
  510.     result = (aChar == CR);
  511.              
  512.     return(result);
  513. }
  514.  
  515. Boolean        IsContentsToken(TextToken* theToken)
  516. {
  517.     return(IsAtStart(theToken) && IsAtEnd(theToken));
  518. }
  519.  
  520. Boolean        IsParagraphToken(TextToken* theToken, short* start, short* end)
  521. {
  522.     TEHandle    aTEH;
  523.     OSErr        err;
  524.     short        number;
  525.     Boolean        fStart,
  526.                 fEnd,
  527.                 result;
  528.     
  529. //    if (IsContentsToken(theToken))    // So we don't start and end 
  530. //        return(false);
  531.         
  532.     aTEH = TEHandleFromTextToken(theToken);
  533.         
  534.                                     // What about having CR's before end??
  535.                                     // - then it's just more paragraphs?
  536.                                     // - in STE yes - ahhh it'll be okay
  537.         
  538.     fStart = IsAtStart(theToken) || IsParagraphDelimiter(GetTEHChar(aTEH, theToken->tokenOffset - 1));
  539.     fEnd = IsAtEnd(theToken) || IsParagraphDelimiter(GetTEHChar(aTEH, theToken->tokenOffset + theToken->tokenLength));
  540.     
  541.     if (fStart && fEnd)
  542.     {
  543.         // need to do a count of the paragraphs
  544.         
  545.         err = CountTextElements(aTEH, theToken->tokenOffset,
  546.                             theToken->tokenLength, cParagraph, &number);
  547.  
  548.         // count text elements before it i.e. offset == 0 limit == theToken->tokenOffset
  549.         
  550.         if (IsAtStart(theToken))
  551.             *start = 1;
  552.         else
  553.         {                // From beginning to charracter before start of paragraph
  554.             err = CountTextElements(aTEH, 1,theToken->tokenOffset - 1, cParagraph, start);
  555.             (*start)++;
  556.         }
  557.         
  558.         *end = *start + number - 1;
  559.         
  560.         result = true;
  561.     }
  562.     else
  563.         result = false;
  564.     
  565.     return(result);
  566. }
  567.  
  568. Boolean        IsWordToken(TextToken* theToken, short* start, short* end)
  569. {
  570.     TEHandle    aTEH;
  571.     OSErr        err;
  572.     short        number;
  573.     Boolean        fStart,
  574.                 fEnd,
  575.                 result;
  576.     
  577. //    if (IsContentsToken(theToken) || IsParagraphToken(theToken, start, end))
  578. //        return(false);
  579.     
  580.     aTEH = TEHandleFromTextToken(theToken);
  581.         
  582.                                     // What about having CR's before end??
  583.                                     // - then it's just more paragraphs?
  584.                                     // - in STE yes - ahhh it'll be okay
  585.         
  586.     fStart = IsAtStart(theToken) || IsWhiteSpace(GetTEHChar(aTEH, theToken->tokenOffset - 1));
  587.     fEnd = IsAtEnd(theToken) || IsWhiteSpace(GetTEHChar(aTEH, theToken->tokenOffset + theToken->tokenLength));
  588.     
  589.     if (fStart && fEnd)
  590.     {
  591.         // need to do a count of the words
  592.         
  593.         err = CountTextElements(aTEH, theToken->tokenOffset,
  594.                             theToken->tokenLength, cWord, &number);
  595.  
  596.         // count text elements before it i.e. offset == 0 limit == theToken->tokenOffset
  597.         
  598.         if (IsAtStart(theToken))
  599.             *start = 1;
  600.         else
  601.         {                // From beginning to charracter before start of word
  602.             err = CountTextElements(aTEH, 1, theToken->tokenOffset - 1, cWord, start);
  603.             (*start)++;
  604.         }
  605.         
  606.         *end = *start + number - 1;
  607.         
  608.         result = true;
  609.     }
  610.     else
  611.         result = false;
  612.     
  613.     return(result);
  614. }
  615.  
  616.  
  617. DescType    GetTextTokenType(TextToken* theToken, short* start, short* end)
  618. {
  619.     DescType    result;
  620.     
  621.     *start = *end = -1;                    // Just set to the same value
  622.  
  623.     if (! theToken->tokenLength)
  624.     {
  625.         result = cInsertionPoint;
  626.     }
  627.     else if (IsContentsToken(theToken))
  628.     {
  629.         result = pContents;
  630.     }
  631.     else if (IsParagraphToken(theToken, start, end))
  632.     {
  633.         result = cParagraph;
  634.     }
  635.     else if (IsWordToken(theToken, start, end))
  636.     {
  637.         result = cWord;
  638.     }
  639.     else
  640.     {
  641.         result = cChar;
  642.         *start = theToken->tokenOffset;
  643.         *end = theToken->tokenOffset + theToken->tokenLength - 1;
  644.     }
  645.     
  646.     return(result);
  647. }
  648.  
  649. OSErr    MakeContentsSpecifier(TextToken* theToken, AEDesc* result)
  650. {
  651.     AEDesc        docSpec = {typeNull, NULL},
  652.                 contentsDesc = {typeNull, NULL};
  653.     DescType    propertyID;
  654.     OSErr        err;
  655.  
  656.     err = MakeDocumentObj(theToken->tokenWindow, &docSpec);
  657.     if (noErr != err) goto done;
  658.     
  659.     propertyID = pContents;
  660.     err = AECreateDesc(typeType, (Ptr)&propertyID, sizeof(DescType), &contentsDesc);
  661.     if (err != noErr) goto done;
  662.     err = CreateObjSpecifier(cProperty, &docSpec, formPropertyID, &contentsDesc, false, result);
  663.  
  664. done:
  665.     if (docSpec.dataHandle)
  666.         AEDisposeDesc(&docSpec);
  667.     if (contentsDesc.dataHandle)
  668.         AEDisposeDesc(&contentsDesc);
  669.     
  670.     return(err);
  671. }
  672.  
  673.  
  674. OSErr    MakeAbsoluteTextSpecifier(WindowPtr theWindow, DescType textType, long index, AEDesc* result)
  675. {
  676.     AEDesc        docSpec = {typeNull, NULL},
  677.                 absoluteDesc = {typeNull, NULL};
  678.     OSErr        err;
  679.     
  680.     if (theWindow)
  681.     {
  682.         err = MakeDocumentObj(theWindow, &docSpec);
  683.         if (noErr != err) goto done;
  684.     }
  685.     // else just use the NULL'ed value
  686.  
  687.     err = AECreateDesc(typeLongInteger, (Ptr)&index, sizeof(index), &absoluteDesc);
  688.     if (err != noErr) goto done;
  689.     err = CreateObjSpecifier(textType, &docSpec, formAbsolutePosition,
  690.                                                     &absoluteDesc, false, result);
  691.  
  692. done:
  693.     if (docSpec.dataHandle)
  694.         AEDisposeDesc(&docSpec);
  695.     if (absoluteDesc.dataHandle)
  696.         AEDisposeDesc(&absoluteDesc);
  697.     
  698.     return(err);
  699. }
  700.  
  701.  
  702. OSErr    MakeInsertionPointSpecifier(TextToken* theToken, AEDesc* result)
  703. {
  704.     AEDesc        relativeToSpec,
  705.                 relativeDesc;
  706.     DescType    relativeType;
  707.     OSErr        err;
  708.  
  709.     if (IsAtStart(theToken))            // Before contents (whether there are any or not)
  710.     {
  711.         relativeType = kAEPrevious;
  712.         err = MakeContentsSpecifier(theToken, &relativeToSpec);
  713.     }
  714.     else if (IsAtEnd(theToken))            // After last character
  715.     {
  716.         relativeType = kAENext;
  717.         //err = MakeContentsSpecifier(theToken, &relativeToSpec);
  718.         err = MakeAbsoluteTextSpecifier(theToken->tokenWindow, cChar, -1, &relativeToSpec);
  719.     }
  720.     else                                // Has a character it can go before
  721.     {
  722.         relativeType = kAEPrevious;
  723.         err = MakeAbsoluteTextSpecifier(theToken->tokenWindow, cChar, theToken->tokenOffset, &relativeToSpec);
  724.     }
  725.  
  726.     if (noErr != err) goto done;
  727.     
  728.       err = AECreateDesc(typeEnumerated, &relativeType, sizeof(relativeType), &relativeDesc);
  729.     if (noErr != err) goto done;
  730.     err = CreateObjSpecifier(cInsertionPoint, &relativeToSpec, formRelativePosition,
  731.                                                                    &relativeDesc, false, result);
  732.  
  733. done:
  734.     if (relativeToSpec.dataHandle)
  735.         AEDisposeDesc(&relativeToSpec);
  736.     if (relativeDesc.dataHandle)
  737.         AEDisposeDesc(&relativeDesc);
  738.  
  739.     return(err);
  740. }
  741.  
  742. OSErr    GetIndexSpecifier(TextToken* theToken, DescType textType, long index, AEDesc* result)
  743. {
  744.     OSErr    err;
  745.  
  746.     switch (textType)
  747.     {
  748.         case cInsertionPoint:
  749.             err = MakeInsertionPointSpecifier(theToken, result);
  750.             break;
  751.             
  752.         case pContents:
  753.             err = MakeContentsSpecifier(theToken, result);
  754.             break;
  755.             
  756.         case cParagraph:
  757.         case cWord:
  758.         case cChar:
  759.             err = MakeAbsoluteTextSpecifier(theToken->tokenWindow, textType, index, result);
  760.             break;
  761.         
  762.         default:
  763.             err = errAETypeError;
  764.     }
  765.     
  766.     return(err);
  767. }
  768.  
  769.  
  770. OSErr    GetTextTokenObjectSpecifier(TextToken* theToken, AEDesc* result)
  771. {
  772.     AEDesc        docSpec = {typeNull, NULL},
  773.                 startSpec = {typeNull, NULL},
  774.                 endSpec = {typeNull, NULL},
  775.                 rangeDesc = {typeNull, NULL};
  776.     DescType    textType;
  777.     short        start,
  778.                 end;
  779.     OSErr        err;
  780.     
  781.     textType = GetTextTokenType(theToken, &start, &end);
  782.     
  783.     err = GetIndexSpecifier(theToken, textType, start, &startSpec);
  784.     if (noErr != err) goto done;
  785.  
  786.     if (start != end)        // Sort out rest of range specifier
  787.     {
  788.         err = GetIndexSpecifier(theToken, textType, end, &endSpec);
  789.         if (noErr != err) goto done;
  790.         
  791.         err = CreateRangeDescriptor(&startSpec, &endSpec, false, &rangeDesc);
  792.         if (noErr != err) goto done;
  793.  
  794.         err = MakeDocumentObj(theToken->tokenWindow, &docSpec);
  795.         if (noErr != err) goto done;
  796.  
  797.         err = CreateObjSpecifier(cText, &docSpec, formRange, &rangeDesc, false, result);
  798.     }
  799.     else
  800.         err = AEDuplicateDesc(&startSpec, result);
  801.     
  802. done:
  803.     if (docSpec.dataHandle)
  804.         AEDisposeDesc(&docSpec);
  805.     if (startSpec.dataHandle)
  806.         AEDisposeDesc(&startSpec);
  807.     if (endSpec.dataHandle)
  808.         AEDisposeDesc(&endSpec);
  809.     if (rangeDesc.dataHandle)
  810.         AEDisposeDesc(&rangeDesc);
  811.  
  812.     return(err);
  813. }
  814.